package com.jvm.synchronizedp;

/**
 *
 * 分析代码是否互斥的方法，
 * 先找出 synchronized 作用的对象是谁，
 * 如果多个线程操作的方法中 synchronized 作用的锁对象一样，
 * 那么这些线程同时异步执行这些方法就是互斥的。
 *
 */
public class Demo5 {

    // 作用于当前类的实例对象
    public synchronized void m1() {
        //
    }

    // 作用于当前类的实例对象
    public synchronized void m2() {
        //
    }

    // 作用于当前类的实例对象
    public void m3() {
        synchronized (this) {
            //
        }
    }

    // 作用于当前类 Class 对象
    public static synchronized void m4() {
        //
    }

    // 作用于当前类 Class 对象
    public static void m5() {
        synchronized (Demo5.class) {
            //
        }
    }

    public static class T extends Thread {
        Demo5 demo5;

        public T(Demo5 demo5) {
            this.demo5 = demo5;
        }

        @Override
        public void run() {
            super.run();
        }
    }


    public static void main(String[] args) {

        /**
         *
         * 线程 t1、t2、t3 中调用的方法都需要获取 d1 的锁，所以他们是互斥的
            t1/t2/t3 这 3 个线程和 t4 不互斥，他们可以同时运行，因为前面三个线程依赖于 d1 的锁，t4 依赖于 d2 的锁
            t5、t6 都作用于当前类的 Class 对象锁，所以这两个线程是互斥的，和其他几个线程不互斥
         *
         *
         */

        Demo5 d1 = new Demo5();
        Thread t1 = new Thread(() -> {
            d1.m1();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            d1.m2();
        });
        t2.start();

        Thread t3 = new Thread(() -> {
            d1.m2();
        });
        t3.start();

        Demo5 d2 = new Demo5();
        Thread t4 = new Thread(() -> {
            d2.m2();
        });
        t4.start();

        Thread t5 = new Thread(() -> {
            Demo5.m4();
        });
        t5.start();

        Thread t6 = new Thread(() -> {
            Demo5.m5();
        });
        t6.start();


    }

}
